---
layout: "default"
title: "Operator: =="
description: "Swift documentation for the '==' operator."
root: "/v4.2"
---

<code class="language-swift"> operator == {
    associativity 
    precedence 
}</code>

<h3>Declarations</h3>

<div class="declaration" id="func-eqeq_-rhs_">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-rhs_">func ==(<wbr>_: (<wbr>), rhs: ())</a>
        
<div class="comment collapse" id="comment-func-eqeq_-rhs_"><div class="p">
    <p>Returns a Boolean value indicating whether the corresponding components of
two tuples are equal.</p>

<p>All arity zero tuples are equal.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> An empty tuple.
  <strong>rhs:</strong> An empty tuple.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: (), rhs: ()) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-any-type-t1_-any-type">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-any-type-t1_-any-type">func ==(<wbr>_:<wbr> Any.Type?, t1: Any.Type?)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-any-type-t1_-any-type"><div class="p">
    <p>Returns a Boolean value indicating whether two types are identical.</p>

<p><strong>Parameters:</strong>
  <strong>t0:</strong> A type to compare.
  <strong>t1:</strong> Another type to compare.
<strong>Returns:</strong> <code>true</code> if both <code>t0</code> and <code>t1</code> are <code>nil</code> or if they represent the
  same type; otherwise, <code>false</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(t0: Any.Type?, t1: Any.Type?) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a-b-c-d-e-f_-a-b-c-d-e-f-rhs_-a-b-c-d-e-f">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a-b-c-d-e-f_-a-b-c-d-e-f-rhs_-a-b-c-d-e-f">func == &lt;A, B, C, D, E, F&gt;(<wbr>_: (<wbr>A, B, C, D, E, F), rhs: (A, B, C, D, E, F))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a-b-c-d-e-f_-a-b-c-d-e-f-rhs_-a-b-c-d-e-f"><div class="p">
    <p>Returns a Boolean value indicating whether the corresponding components of
two tuples are equal.</p>

<p>For two tuples to compare as equal, each corresponding pair of components
must be equal. The following example compares tuples made up of 6
components:</p>

<pre><code class="language-swift">let a = (&quot;a&quot;, 1, 2, 3, 4, 5)
let b = (&quot;a&quot;, 1, 2, 3, 4, 5)
print(a == b)
// Prints &quot;true&quot;

let c = (&quot;a&quot;, 1, 2, 3, 4, 6)
print(a == c)
// Prints &quot;false&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A tuple of <code>Equatable</code> elements.
  <strong>rhs:</strong> Another tuple of elements of the same type as <code>lhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A, B, C, D, E, F&gt;(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -&gt; Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a-b-c-d-e_-a-b-c-d-e-rhs_-a-b-c-d-e">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a-b-c-d-e_-a-b-c-d-e-rhs_-a-b-c-d-e">func == &lt;A, B, C, D, E&gt;(<wbr>_: (<wbr>A, B, C, D, E), rhs: (A, B, C, D, E))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a-b-c-d-e_-a-b-c-d-e-rhs_-a-b-c-d-e"><div class="p">
    <p>Returns a Boolean value indicating whether the corresponding components of
two tuples are equal.</p>

<p>For two tuples to compare as equal, each corresponding pair of components
must be equal. The following example compares tuples made up of 5
components:</p>

<pre><code class="language-swift">let a = (&quot;a&quot;, 1, 2, 3, 4)
let b = (&quot;a&quot;, 1, 2, 3, 4)
print(a == b)
// Prints &quot;true&quot;

let c = (&quot;a&quot;, 1, 2, 3, 5)
print(a == c)
// Prints &quot;false&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A tuple of <code>Equatable</code> elements.
  <strong>rhs:</strong> Another tuple of elements of the same type as <code>lhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A, B, C, D, E&gt;(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -&gt; Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a-b-c-d_-a-b-c-d-rhs_-a-b-c-d">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a-b-c-d_-a-b-c-d-rhs_-a-b-c-d">func == &lt;A, B, C, D&gt;(<wbr>_: (<wbr>A, B, C, D), rhs: (A, B, C, D))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a-b-c-d_-a-b-c-d-rhs_-a-b-c-d"><div class="p">
    <p>Returns a Boolean value indicating whether the corresponding components of
two tuples are equal.</p>

<p>For two tuples to compare as equal, each corresponding pair of components
must be equal. The following example compares tuples made up of 4
components:</p>

<pre><code class="language-swift">let a = (&quot;a&quot;, 1, 2, 3)
let b = (&quot;a&quot;, 1, 2, 3)
print(a == b)
// Prints &quot;true&quot;

let c = (&quot;a&quot;, 1, 2, 4)
print(a == c)
// Prints &quot;false&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A tuple of <code>Equatable</code> elements.
  <strong>rhs:</strong> Another tuple of elements of the same type as <code>lhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A, B, C, D&gt;(lhs: (A, B, C, D), rhs: (A, B, C, D)) -&gt; Bool where A : Equatable, B : Equatable, C : Equatable, D : Equatable</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a-b-c_-a-b-c-rhs_-a-b-c">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a-b-c_-a-b-c-rhs_-a-b-c">func == &lt;A, B, C&gt;(<wbr>_: (<wbr>A, B, C), rhs: (A, B, C))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a-b-c_-a-b-c-rhs_-a-b-c"><div class="p">
    <p>Returns a Boolean value indicating whether the corresponding components of
two tuples are equal.</p>

<p>For two tuples to compare as equal, each corresponding pair of components
must be equal. The following example compares tuples made up of 3
components:</p>

<pre><code class="language-swift">let a = (&quot;a&quot;, 1, 2)
let b = (&quot;a&quot;, 1, 2)
print(a == b)
// Prints &quot;true&quot;

let c = (&quot;a&quot;, 1, 3)
print(a == c)
// Prints &quot;false&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A tuple of <code>Equatable</code> elements.
  <strong>rhs:</strong> Another tuple of elements of the same type as <code>lhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A, B, C&gt;(lhs: (A, B, C), rhs: (A, B, C)) -&gt; Bool where A : Equatable, B : Equatable, C : Equatable</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-a-b_-a-b-rhs_-a-b">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-a-b_-a-b-rhs_-a-b">func == &lt;A, B&gt;(<wbr>_: (<wbr>A, B), rhs: (A, B))</a>
        
<div class="comment collapse" id="comment-func-eqeq-a-b_-a-b-rhs_-a-b"><div class="p">
    <p>Returns a Boolean value indicating whether the corresponding components of
two tuples are equal.</p>

<p>For two tuples to compare as equal, each corresponding pair of components
must be equal. The following example compares tuples made up of 2
components:</p>

<pre><code class="language-swift">let a = (&quot;a&quot;, 1)
let b = (&quot;a&quot;, 1)
print(a == b)
// Prints &quot;true&quot;

let c = (&quot;a&quot;, 2)
print(a == c)
// Prints &quot;false&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A tuple of <code>Equatable</code> elements.
  <strong>rhs:</strong> Another tuple of elements of the same type as <code>lhs</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;A, B&gt;(lhs: (A, B), rhs: (A, B)) -&gt; Bool where A : Equatable, B : Equatable</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq-t_-t-rhs_-t">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-t_-t-rhs_-t">func == &lt;T&gt;(<wbr>_:<wbr> T, rhs: T)</a>
        
<div class="comment collapse" id="comment-func-eqeq-t_-t-rhs_-t"><div class="p">
    <p>Returns a Boolean value indicating whether the two arguments are equal.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A raw-representable instance.
  <strong>rhs:</strong> A second raw-representable instance.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;T&gt;(lhs: T, rhs: T) -&gt; Bool where T : RawRepresentable, T.RawValue : Equatable</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-anykeypath-b_-anykeypath">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-anykeypath-b_-anykeypath">func ==(<wbr>_:<wbr> AnyKeyPath, b: AnyKeyPath)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-anykeypath-b_-anykeypath"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(a: AnyKeyPath, b: AnyKeyPath) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-element-element-rhs_-element-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-element-element-rhs_-element-element">func ==(<wbr>_:<wbr> [[Element].Element], rhs: [[Element].Element])</a>
        
<div class="comment collapse" id="comment-func-eqeq_-element-element-rhs_-element-element"><div class="p">
    <p>Returns a Boolean value indicating whether two arrays contain the same
elements in the same order.</p>

<p>You can use the equal-to operator (<code>==</code>) to compare any two arrays
that store the same, <code>Equatable</code>-conforming element type.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> An array to compare.
  <strong>rhs:</strong> Another array to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: [[Element].Element], rhs: [[Element].Element]) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-key_-value-rhs_-key_-value">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-key_-value-rhs_-key_-value">func ==(<wbr>_:<wbr> [Key :<wbr> Value], rhs:<wbr> [Key : Value])</a>
        
<div class="comment collapse" id="comment-func-eqeq_-key_-value-rhs_-key_-value"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: [Key : Value], rhs: [Key : Value]) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-optionalnilcomparisontype-rhs_-wrapped">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-optionalnilcomparisontype-rhs_-wrapped">func ==(<wbr>_:<wbr> _OptionalNilComparisonType, rhs: Wrapped?)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-optionalnilcomparisontype-rhs_-wrapped"><div class="p">
    <p>Returns a Boolean value indicating whether the right-hand-side argument is
<code>nil</code>.</p>

<p>You can use this equal-to operator (<code>==</code>) to test whether an optional
instance is <code>nil</code> even when the wrapped value&#39;s type does not conform to
the <code>Equatable</code> protocol.</p>

<p>The following example declares the <code>stream</code> variable as an optional
instance of a hypothetical <code>DataStream</code> type. Although <code>DataStream</code> is not
an <code>Equatable</code> type, this operator allows checking whether <code>stream</code> is
<code>nil</code>.</p>

<pre><code class="language-swift">var stream: DataStream? = nil
if nil == stream {
    print(&quot;No data stream is configured.&quot;)
}
// Prints &quot;No data stream is configured.&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A <code>nil</code> literal.
  <strong>rhs:</strong> A value to compare to <code>nil</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: _OptionalNilComparisonType, rhs: Wrapped?) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-anyhashable-rhs_-anyhashable">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-anyhashable-rhs_-anyhashable">func ==(<wbr>_:<wbr> AnyHashable, rhs: AnyHashable)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-anyhashable-rhs_-anyhashable"><div class="p">
    <p>Returns a Boolean value indicating whether two type-erased hashable
instances wrap the same type and value.</p>

<p>Two instances of <code>AnyHashable</code> compare as equal if and only if the
underlying types have the same conformance to the <code>Equatable</code> protocol
and the underlying values compare as equal.</p>

<p>The following example creates two type-erased hashable values: <code>x</code> wraps
an <code>Int</code> with the value 42, while <code>y</code> wraps a <code>UInt8</code> with the same
numeric value. Because the underlying types of <code>x</code> and <code>y</code> are
different, the two variables do not compare as equal despite having
equal underlying values.</p>

<pre><code class="language-swift">let x = AnyHashable(Int(42))
let y = AnyHashable(UInt8(42))

print(x == y)
// Prints &quot;false&quot; because `Int` and `UInt8` are different types

print(x == AnyHashable(Int(42)))
// Prints &quot;true&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A type-erased hashable value.
  <strong>rhs:</strong> Another type-erased hashable value.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: AnyHashable, rhs: AnyHashable) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-anyindex-rhs_-anyindex">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-anyindex-rhs_-anyindex">func ==(<wbr>_:<wbr> AnyIndex, rhs: AnyIndex)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-anyindex-rhs_-anyindex"><div class="p">
    <p>Returns a Boolean value indicating whether two indices wrap equal
underlying indices.</p>

<p>The types of the two underlying indices must be identical.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> An index to compare.
  <strong>rhs:</strong> Another index to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: AnyIndex, rhs: AnyIndex) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-arrayslice-arrayslice-element-element-rhs_-arrayslice-arrayslice-element-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-arrayslice-arrayslice-element-element-rhs_-arrayslice-arrayslice-element-element">func ==(<wbr>_:<wbr> ArraySlice&lt;ArraySlice&lt;Element&gt;.Element&gt;, rhs: ArraySlice&lt;ArraySlice&lt;Element&gt;.Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-arrayslice-arrayslice-element-element-rhs_-arrayslice-arrayslice-element-element"><div class="p">
    <p>Returns a Boolean value indicating whether two arrays contain the same
elements in the same order.</p>

<p>You can use the equal-to operator (<code>==</code>) to compare any two arrays
that store the same, <code>Equatable</code>-conforming element type.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> An array to compare.
  <strong>rhs:</strong> Another array to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: ArraySlice&lt;ArraySlice&lt;Element&gt;.Element&gt;, rhs: ArraySlice&lt;ArraySlice&lt;Element&gt;.Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-autoreleasingunsafemutablepointer-pointee-rhs_-autoreleasingunsafemutablepointer-pointee">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-autoreleasingunsafemutablepointer-pointee-rhs_-autoreleasingunsafemutablepointer-pointee">func ==(<wbr>_:<wbr> AutoreleasingUnsafeMutablePointer&lt;Pointee&gt;, rhs: AutoreleasingUnsafeMutablePointer&lt;Pointee&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-autoreleasingunsafemutablepointer-pointee-rhs_-autoreleasingunsafemutablepointer-pointee"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: AutoreleasingUnsafeMutablePointer&lt;Pointee&gt;, rhs: AutoreleasingUnsafeMutablePointer&lt;Pointee&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-bool-rhs_-bool">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-bool-rhs_-bool">func ==(<wbr>_:<wbr> Bool, rhs: Bool)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-bool-rhs_-bool"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Bool, rhs: Bool) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-character-rhs_-character">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-character-rhs_-character">func ==(<wbr>_:<wbr> Character, rhs: Character)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-character-rhs_-character"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Character, rhs: Character) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-character-unicodescalarview-index-rhs_-character-unicodescalarview-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-character-unicodescalarview-index-rhs_-character-unicodescalarview-index">func ==(<wbr>_:<wbr> Character.UnicodeScalarView.Index, rhs: Character.UnicodeScalarView.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-character-unicodescalarview-index-rhs_-character-unicodescalarview-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Character.UnicodeScalarView.Index, rhs: Character.UnicodeScalarView.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-closedrange-bound-rhs_-closedrange-bound">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-closedrange-bound-rhs_-closedrange-bound">func ==(<wbr>_:<wbr> ClosedRange&lt;Bound&gt;, rhs: ClosedRange&lt;Bound&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-closedrange-bound-rhs_-closedrange-bound"><div class="p">
    <p>Returns a Boolean value indicating whether two ranges are equal.</p>

<p>Two ranges are equal when they have the same lower and upper bounds.</p>

<pre><code class="language-swift">let x: ClosedRange = 5...15
print(x == 5...15)
// Prints &quot;true&quot;
print(x == 10...20)
// Prints &quot;false&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range to compare.
  <strong>rhs:</strong> Another range to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: ClosedRange&lt;Bound&gt;, rhs: ClosedRange&lt;Bound&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-closedrange-bound-index-rhs_-closedrange-bound-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-closedrange-bound-index-rhs_-closedrange-bound-index">func ==(<wbr>_:<wbr> ClosedRange&lt;Bound&gt;.Index, rhs: ClosedRange&lt;Bound&gt;.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-closedrange-bound-index-rhs_-closedrange-bound-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: ClosedRange&lt;Bound&gt;.Index, rhs: ClosedRange&lt;Bound&gt;.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-codinguserinfokey-rhs_-codinguserinfokey">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-codinguserinfokey-rhs_-codinguserinfokey">func ==(<wbr>_:<wbr> CodingUserInfoKey, rhs: CodingUserInfoKey)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-codinguserinfokey-rhs_-codinguserinfokey"><div class="p">
    <p>Returns a Boolean value indicating whether the given keys are equal.</p>

<p><strong><code>lhs</code>:</strong>  The key to compare against.</p>

<p><strong><code>rhs</code>:</strong>  The key to compare with.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: CodingUserInfoKey, rhs: CodingUserInfoKey) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-contiguousarray-contiguousarray-element-element-rhs_-contiguousarray-contiguousarray-element-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-contiguousarray-contiguousarray-element-element-rhs_-contiguousarray-contiguousarray-element-element">func ==(<wbr>_:<wbr> ContiguousArray&lt;ContiguousArray&lt;Element&gt;.Element&gt;, rhs: ContiguousArray&lt;ContiguousArray&lt;Element&gt;.Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-contiguousarray-contiguousarray-element-element-rhs_-contiguousarray-contiguousarray-element-element"><div class="p">
    <p>Returns a Boolean value indicating whether two arrays contain the same
elements in the same order.</p>

<p>You can use the equal-to operator (<code>==</code>) to compare any two arrays
that store the same, <code>Equatable</code>-conforming element type.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> An array to compare.
  <strong>rhs:</strong> Another array to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: ContiguousArray&lt;ContiguousArray&lt;Element&gt;.Element&gt;, rhs: ContiguousArray&lt;ContiguousArray&lt;Element&gt;.Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-dictionary-key-value-index-rhs_-dictionary-key-value-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-dictionary-key-value-index-rhs_-dictionary-key-value-index">func ==(<wbr>_:<wbr> Dictionary&lt;Key, Value&gt;.Index, rhs: Dictionary&lt;Key, Value&gt;.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-dictionary-key-value-index-rhs_-dictionary-key-value-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Dictionary&lt;Key, Value&gt;.Index, rhs: Dictionary&lt;Key, Value&gt;.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-dictionary-key-value-keys-rhs_-dictionary-key-value-keys">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-dictionary-key-value-keys-rhs_-dictionary-key-value-keys">func ==(<wbr>_:<wbr> Dictionary&lt;Key, Value&gt;.Keys, rhs: Dictionary&lt;Key, Value&gt;.Keys)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-dictionary-key-value-keys-rhs_-dictionary-key-value-keys"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Dictionary&lt;Key, Value&gt;.Keys, rhs: Dictionary&lt;Key, Value&gt;.Keys) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-emptycollection-element-rhs_-emptycollection-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-emptycollection-element-rhs_-emptycollection-element">func ==(<wbr>_:<wbr> EmptyCollection&lt;Element&gt;, rhs: EmptyCollection&lt;Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-emptycollection-element-rhs_-emptycollection-element"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: EmptyCollection&lt;Element&gt;, rhs: EmptyCollection&lt;Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-flattencollection-base-index-rhs_-flattencollection-base-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-flattencollection-base-index-rhs_-flattencollection-base-index">func ==(<wbr>_:<wbr> FlattenCollection&lt;Base&gt;.Index, rhs: FlattenCollection&lt;Base&gt;.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-flattencollection-base-index-rhs_-flattencollection-base-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: FlattenCollection&lt;Base&gt;.Index, rhs: FlattenCollection&lt;Base&gt;.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int-rhs_-int">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int-rhs_-int">func ==(<wbr>_:<wbr> Int, rhs: Int)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int-rhs_-int"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int, rhs: Int) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Int/"><code>Int</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int8-rhs_-int8">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int8-rhs_-int8">func ==(<wbr>_:<wbr> Int8, rhs: Int8)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int8-rhs_-int8"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int8, rhs: Int8) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Int8/"><code>Int8</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int16-rhs_-int16">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int16-rhs_-int16">func ==(<wbr>_:<wbr> Int16, rhs: Int16)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int16-rhs_-int16"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int16, rhs: Int16) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Int16/"><code>Int16</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int32-rhs_-int32">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int32-rhs_-int32">func ==(<wbr>_:<wbr> Int32, rhs: Int32)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int32-rhs_-int32"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int32, rhs: Int32) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Int32/"><code>Int32</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-int64-rhs_-int64">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-int64-rhs_-int64">func ==(<wbr>_:<wbr> Int64, rhs: Int64)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-int64-rhs_-int64"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Int64, rhs: Int64) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Int64/"><code>Int64</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-lazydropwhilecollection-base-index-rhs_-lazydropwhilecollection-base-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-lazydropwhilecollection-base-index-rhs_-lazydropwhilecollection-base-index">func ==(<wbr>_:<wbr> LazyDropWhileCollection&lt;Base&gt;.Index, rhs: LazyDropWhileCollection&lt;Base&gt;.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-lazydropwhilecollection-base-index-rhs_-lazydropwhilecollection-base-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: LazyDropWhileCollection&lt;Base&gt;.Index, rhs: LazyDropWhileCollection&lt;Base&gt;.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-lazyprefixwhilecollection-base-index-rhs_-lazyprefixwhilecollection-base-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-lazyprefixwhilecollection-base-index-rhs_-lazyprefixwhilecollection-base-index">func ==(<wbr>_:<wbr> LazyPrefixWhileCollection&lt;Base&gt;.Index, rhs: LazyPrefixWhileCollection&lt;Base&gt;.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-lazyprefixwhilecollection-base-index-rhs_-lazyprefixwhilecollection-base-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: LazyPrefixWhileCollection&lt;Base&gt;.Index, rhs: LazyPrefixWhileCollection&lt;Base&gt;.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-managedbufferpointer-header-element-rhs_-managedbufferpointer-header-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-managedbufferpointer-header-element-rhs_-managedbufferpointer-header-element">func ==(<wbr>_:<wbr> ManagedBufferPointer&lt;Header, Element&gt;, rhs: ManagedBufferPointer&lt;Header, Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-managedbufferpointer-header-element-rhs_-managedbufferpointer-header-element"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: ManagedBufferPointer&lt;Header, Element&gt;, rhs: ManagedBufferPointer&lt;Header, Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-opaquepointer-rhs_-opaquepointer">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-opaquepointer-rhs_-opaquepointer">func ==(<wbr>_:<wbr> OpaquePointer, rhs: OpaquePointer)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-opaquepointer-rhs_-opaquepointer"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: OpaquePointer, rhs: OpaquePointer) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-range-range-bound-bound-rhs_-range-range-bound-bound">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-range-range-bound-bound-rhs_-range-range-bound-bound">func ==(<wbr>_:<wbr> Range&lt;Range&lt;Bound&gt;.Bound&gt;, rhs: Range&lt;Range&lt;Bound&gt;.Bound&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-range-range-bound-bound-rhs_-range-range-bound-bound"><div class="p">
    <p>Returns a Boolean value indicating whether two ranges are equal.</p>

<p>Two ranges are equal when they have the same lower and upper bounds.
That requirement holds even for empty ranges.</p>

<pre><code class="language-swift">let x: Range = 5..&lt;15
print(x == 5..&lt;15)
// Prints &quot;true&quot;

let y: Range = 5..&lt;5
print(y == 15..&lt;15)
// Prints &quot;false&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A range to compare.
  <strong>rhs:</strong> Another range to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Range&lt;Range&lt;Bound&gt;.Bound&gt;, rhs: Range&lt;Range&lt;Bound&gt;.Bound&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-reversedcollection-base-index-rhs_-reversedcollection-base-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-reversedcollection-base-index-rhs_-reversedcollection-base-index">func ==(<wbr>_:<wbr> ReversedCollection&lt;Base&gt;.Index, rhs: ReversedCollection&lt;Base&gt;.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-reversedcollection-base-index-rhs_-reversedcollection-base-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: ReversedCollection&lt;Base&gt;.Index, rhs: ReversedCollection&lt;Base&gt;.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-rhs_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-rhs_-self">func ==(<wbr>_:<wbr> Self, rhs: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-rhs_-self"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Self, rhs: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/BinaryFloatingPoint/"><code>BinaryFloatingPoint</code></a>,    <a href="../../protocol/FloatingPoint/"><code>FloatingPoint</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-set-element-rhs_-set-element">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-set-element-rhs_-set-element">func ==(<wbr>_:<wbr> Set&lt;Element&gt;, rhs: Set&lt;Element&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-set-element-rhs_-set-element"><div class="p">
    <p>Returns a Boolean value indicating whether two sets have equal elements.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A set.
  <strong>rhs:</strong> Another set.
<strong>Returns:</strong> <code>true</code> if the <code>lhs</code> and <code>rhs</code> have the same elements; otherwise,
  <code>false</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Set&lt;Element&gt;, rhs: Set&lt;Element&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-set-element-index-rhs_-set-element-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-set-element-index-rhs_-set-element-index">func ==(<wbr>_:<wbr> Set&lt;Element&gt;.Index, rhs: Set&lt;Element&gt;.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-set-element-index-rhs_-set-element-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Set&lt;Element&gt;.Index, rhs: Set&lt;Element&gt;.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-string-rhs_-string">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-string-rhs_-string">func ==(<wbr>_:<wbr> String, rhs: String)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-string-rhs_-string"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: String, rhs: String) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-string-index-rhs_-string-index">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-string-index-rhs_-string-index">func ==(<wbr>_:<wbr> String.Index, rhs: String.Index)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-string-index-rhs_-string-index"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: String.Index, rhs: String.Index) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint-rhs_-uint">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint-rhs_-uint">func ==(<wbr>_:<wbr> UInt, rhs: UInt)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint-rhs_-uint"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt, rhs: UInt) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/UInt/"><code>UInt</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint8-rhs_-uint8">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint8-rhs_-uint8">func ==(<wbr>_:<wbr> UInt8, rhs: UInt8)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint8-rhs_-uint8"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt8, rhs: UInt8) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/UInt8/"><code>UInt8</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint16-rhs_-uint16">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint16-rhs_-uint16">func ==(<wbr>_:<wbr> UInt16, rhs: UInt16)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint16-rhs_-uint16"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt16, rhs: UInt16) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/UInt16/"><code>UInt16</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint32-rhs_-uint32">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint32-rhs_-uint32">func ==(<wbr>_:<wbr> UInt32, rhs: UInt32)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint32-rhs_-uint32"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt32, rhs: UInt32) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/UInt32/"><code>UInt32</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-uint64-rhs_-uint64">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-uint64-rhs_-uint64">func ==(<wbr>_:<wbr> UInt64, rhs: UInt64)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-uint64-rhs_-uint64"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UInt64, rhs: UInt64) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/UInt64/"><code>UInt64</code></a>,    <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-unicode-scalar-rhs_-unicode-scalar">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-unicode-scalar-rhs_-unicode-scalar">func ==(<wbr>_:<wbr> Unicode.Scalar, rhs: Unicode.Scalar)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-unicode-scalar-rhs_-unicode-scalar"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Unicode.Scalar, rhs: Unicode.Scalar) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-unicodedecodingresult-rhs_-unicodedecodingresult">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-unicodedecodingresult-rhs_-unicodedecodingresult">func ==(<wbr>_:<wbr> UnicodeDecodingResult, rhs: UnicodeDecodingResult)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-unicodedecodingresult-rhs_-unicodedecodingresult"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UnicodeDecodingResult, rhs: UnicodeDecodingResult) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-unsafemutablepointer-pointee-rhs_-unsafemutablepointer-pointee">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-unsafemutablepointer-pointee-rhs_-unsafemutablepointer-pointee">func ==(<wbr>_:<wbr> UnsafeMutablePointer&lt;Pointee&gt;, rhs: UnsafeMutablePointer&lt;Pointee&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-unsafemutablepointer-pointee-rhs_-unsafemutablepointer-pointee"><div class="p">
    <p>Returns a Boolean value indicating whether two pointers are equal.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A pointer.
  <strong>rhs:</strong> Another pointer.
<strong>Returns:</strong> <code>true</code> if <code>lhs</code> and <code>rhs</code> reference the same memory address;
  otherwise, <code>false</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UnsafeMutablePointer&lt;Pointee&gt;, rhs: UnsafeMutablePointer&lt;Pointee&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-unsafemutablerawpointer-rhs_-unsafemutablerawpointer">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-unsafemutablerawpointer-rhs_-unsafemutablerawpointer">func ==(<wbr>_:<wbr> UnsafeMutableRawPointer, rhs: UnsafeMutableRawPointer)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-unsafemutablerawpointer-rhs_-unsafemutablerawpointer"><div class="p">
    <p>Returns a Boolean value indicating whether two pointers are equal.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A pointer.
  <strong>rhs:</strong> Another pointer.
<strong>Returns:</strong> <code>true</code> if <code>lhs</code> and <code>rhs</code> reference the same memory address;
  otherwise, <code>false</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UnsafeMutableRawPointer, rhs: UnsafeMutableRawPointer) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-unsafepointer-pointee-rhs_-unsafepointer-pointee">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-unsafepointer-pointee-rhs_-unsafepointer-pointee">func ==(<wbr>_:<wbr> UnsafePointer&lt;Pointee&gt;, rhs: UnsafePointer&lt;Pointee&gt;)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-unsafepointer-pointee-rhs_-unsafepointer-pointee"><div class="p">
    <p>Returns a Boolean value indicating whether two pointers are equal.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A pointer.
  <strong>rhs:</strong> Another pointer.
<strong>Returns:</strong> <code>true</code> if <code>lhs</code> and <code>rhs</code> reference the same memory address;
  otherwise, <code>false</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UnsafePointer&lt;Pointee&gt;, rhs: UnsafePointer&lt;Pointee&gt;) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-unsaferawpointer-rhs_-unsaferawpointer">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-unsaferawpointer-rhs_-unsaferawpointer">func ==(<wbr>_:<wbr> UnsafeRawPointer, rhs: UnsafeRawPointer)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-unsaferawpointer-rhs_-unsaferawpointer"><div class="p">
    <p>Returns a Boolean value indicating whether two pointers are equal.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A pointer.
  <strong>rhs:</strong> Another pointer.
<strong>Returns:</strong> <code>true</code> if <code>lhs</code> and <code>rhs</code> reference the same memory address;
  otherwise, <code>false</code>.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: UnsafeRawPointer, rhs: UnsafeRawPointer) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-wrapped-rhs_-optionalnilcomparisontype">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-wrapped-rhs_-optionalnilcomparisontype">func ==(<wbr>_:<wbr> Wrapped?, rhs: _OptionalNilComparisonType)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-wrapped-rhs_-optionalnilcomparisontype"><div class="p">
    <p>Returns a Boolean value indicating whether the left-hand-side argument is
<code>nil</code>.</p>

<p>You can use this equal-to operator (<code>==</code>) to test whether an optional
instance is <code>nil</code> even when the wrapped value&#39;s type does not conform to
the <code>Equatable</code> protocol.</p>

<p>The following example declares the <code>stream</code> variable as an optional
instance of a hypothetical <code>DataStream</code> type. Although <code>DataStream</code> is not
an <code>Equatable</code> type, this operator allows checking whether <code>stream</code> is
<code>nil</code>.</p>

<pre><code class="language-swift">var stream: DataStream? = nil
if stream == nil {
    print(&quot;No data stream is configured.&quot;)
}
// Prints &quot;No data stream is configured.&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare to <code>nil</code>.
  <strong>rhs:</strong> A <code>nil</code> literal.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Wrapped?, rhs: _OptionalNilComparisonType) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-wrapped-rhs_-wrapped">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-wrapped-rhs_-wrapped">func ==(<wbr>_:<wbr> Wrapped?, rhs: Wrapped?)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-wrapped-rhs_-wrapped"><div class="p">
    <p>Returns a Boolean value indicating whether two optional instances are
equal.</p>

<p>Use this equal-to operator (<code>==</code>) to compare any two optional instances of
a type that conforms to the <code>Equatable</code> protocol. The comparison returns
<code>true</code> if both arguments are <code>nil</code> or if the two arguments wrap values
that are equal. Conversely, the comparison returns <code>false</code> if only one of
the arguments is <code>nil</code> or if the two arguments wrap values that are not
equal.</p>

<pre><code class="language-swift">let group1 = [1, 2, 3, 4, 5]
let group2 = [1, 3, 5, 7, 9]
if group1.first == group2.first {
    print(&quot;The two groups start the same.&quot;)
}
// Prints &quot;The two groups start the same.&quot;</code></pre>

<p>You can also use this operator to compare a non-optional value to an
optional that wraps the same type. The non-optional value is wrapped as an
optional before the comparison is made. In the following example, the
<code>numberToMatch</code> constant is wrapped as an optional before comparing to the
optional <code>numberFromString</code>:</p>

<pre><code class="language-swift">let numberToFind: Int = 23
let numberFromString: Int? = Int(&quot;23&quot;)      // Optional(23)
if numberToFind == numberFromString {
    print(&quot;It&#39;s a match!&quot;)
}
// Prints &quot;It&#39;s a match!&quot;</code></pre>

<p>An instance that is expressed as a literal can also be used with this
operator. In the next example, an integer literal is compared with the
optional integer <code>numberFromString</code>. The literal <code>23</code> is inferred as an
<code>Int</code> instance and then wrapped as an optional before the comparison is
performed.</p>

<pre><code class="language-swift">if 23 == numberFromString {
    print(&quot;It&#39;s a match!&quot;)
}
// Prints &quot;It&#39;s a match!&quot;</code></pre>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> An optional value to compare.
  <strong>rhs:</strong> Another optional value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(lhs: Wrapped?, rhs: Wrapped?) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration" id="func-eqeq_-objectidentifier-y_-objectidentifier">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-objectidentifier-y_-objectidentifier">func ==(<wbr>_:<wbr> ObjectIdentifier, y: ObjectIdentifier)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-objectidentifier-y_-objectidentifier"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: ObjectIdentifier, y: ObjectIdentifier) -&gt; Bool</code>
    
    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/BinaryFloatingPoint/"><code>BinaryFloatingPoint</code></a>,    <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/FixedWidthInteger/"><code>FixedWidthInteger</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq_-self-y_-self">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq_-self-y_-self">func ==(<wbr>_:<wbr> Self, y: Self)</a>
        
<div class="comment collapse" id="comment-func-eqeq_-self-y_-self"><div class="p">
    

    <h4>Declaration</h4>    
    <code class="language-swift">func ==(x: Self, y: Self) -&gt; Bool</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/Strideable/"><code>Strideable</code></a>    
</div></div>
</div>
<div class="declaration inherited" id="func-eqeq-s_-self-rhs_-s">
<a class="toggle-link" data-toggle="collapse" href="#comment-func-eqeq-s_-self-rhs_-s">func == &lt;S&gt;(<wbr>_:<wbr> Self, rhs: S)</a>
        
<div class="comment collapse" id="comment-func-eqeq-s_-self-rhs_-s"><div class="p">
    <p>Returns a Boolean value indicating whether two values are equal.</p>

<p>Equality is the inverse of inequality. For any values <code>a</code> and <code>b</code>,
<code>a == b</code> implies that <code>a != b</code> is <code>false</code>.</p>

<p><strong>Parameters:</strong>
  <strong>lhs:</strong> A value to compare.
  <strong>rhs:</strong> Another value to compare.</p>

    <h4>Declaration</h4>    
    <code class="language-swift">func ==&lt;S&gt;(lhs: Self, rhs: S) -&gt; Bool where S : StringProtocol</code>
    
        <h4>Declared In</h4>
        <a href="../../protocol/StringProtocol/"><code>StringProtocol</code></a>    
</div></div>
</div>
